Amiga CD-Sensation: Golden Games/Amiga CD-Sensation - Ausgabe 2 - Golden Games (1996)(GTI - Schatztruhe)(DE)[!].iso/Various/CoreWars/KapitelII

Text File | 1987-12-26 | 87.0 KB | 1,969 lines

    ______________________________________________________________________
   |                                                                      |
   |            ANMERKUNG ZUR DISKETTENVERSION DER ANLEITUNG:             |
   |                                                                      |
   |  Die beiden Abbildungen, auf die im Abschnitt 2.6 und 2.8 zurückge-  |
   |  griffen wird, sind nur in der gedruckten Anleitung enthalten.  Ab-  |
   |  bildung 1 stellt die Statusanzeige eines Kampfes dar, Abbildung 2   |
   |  zeigt die Zeitlupenanzeige (Trace-Menupunkt).                       |
   |______________________________________________________________________|





                 K a p i t e l    2 :    C o r e    W a r s
                 __________________________________________




2.1 Starten und Installieren
____________________________



2.1.1 Allgemeines
-----------------

Dieses Programm ist Shareware. Es darf ausser für gewerbliche Zwecke
frei kopiert und verbreitet werden. Der Preis für die Weitergabe darf
den Betrag für die Diskette und die Kopierarbeit nicht überschreiten!

Das Programm darf nur weitergegeben werden, wenn mindestens die
folgenden Dateien in einem Directory oder auf einer Diskette enthalten
sind:

CoreWars
System (Dir)
     View
LiesMich
Beispiele (Dir)
     Mice
     Mausefalle
     Gnom
     Knirps
     Chang
Anleitung (Dir)
     Einleitung
     KapitelI
     KapitelII
     KapitelIII
     Anhang

Wer das Programm benützt, sollte im Sinne des Shareware-Gedankens
sFr.  30.-- (oder sFr.  33.-- ausserhalb der Schweiz in der jewei-
ligen Landeswährung) an diese Adresse senden:

                         Unicorn  Systems
                          Bernstrasse 67
                         CH-4852 Rothrist

Er erhält dann die etwa 70 Seiten umfassende, deutsche Anleitung in
TeX-Qualität auf Papier sowie die neuste Version des Programmes.  Er
wird ausserdem registrierter Benützer und wird von zukünftigen Updates
in Kenntnis gesetzt.


2.1.2 Installierung
-------------------

Auf Diskette:

Core Wars ist von uns in zwei Versionen in Umlauf gebracht worden. Die
eine besteht aus einer autostartfähigen Diskette mit allen nötigen
Verzeichnissen und Dateien.  Die zweite Version besteht aus einem
einzigen Verzeichnis auf einer handelsüblichen Public Domain Diskette
(Fred Fish, FAUG, Kickstart, AUGE 4000, AUGS u.s.w.).  Um aus den Files
in einem solchen Verzeichnis eine autostartfähige Core Wars Diskette
herzustellen, müssen verschiedene Vorarbeiten geleistet werden.  Auf
einer lauffähigen Core Wars Diskette sollten die unten aufgeführten
Verzeichnisse und Dateien vorhanden sein, wobei die mit einem Stern (*)
gekennzeichneten Dateien vom Core Wars System unbedingt benötigt werden.
Am Einfachsten wird dazu eine original Workbench Diskette (ab Version
1.2) kopiert und auf der Kopie werden dann die überflüssigen Dateien
gelöscht.


*CoreWars            Das Hauptprogramm.
*LiesMich            Allgemeine Informationen über Core Wars.
 Redcode (Dir)       Für eigene Programme vorgesehen.
 c (Dir)             CLI-Befehle und Utilities der Workbench
     LoadIFF         Anzeigen von Bildern im IFF-Format (siehe Anleitung).
     CorePic         Titelbild von CoreWars (nur bei Autostart sichtbar).
 Beispiele (Dir)     Ein Verzeichnis mit einigen Programmbeispielen.
     Mice            Siegerprogramm Welmeisterschaft 1986
     Mausefalle      Schlägt Mice!
     Gnom            \
     Knirps           > weitere Beispielprogramme, siehe Anleitung.
     Chang           /
*System (Dir)        Einige Hilfsprogramme der Workbench.
    *Einstellungen   Einstellungsdatei für den Core Wars Editor.
    *View            Anzeigen von Textdateien (z.B. diesen Text).
*Fonts (Dir)         Zeichensätze, die von Core Wars benötigt werden.
    *Diamond.font    \
    *Diamond (Dir)    > Zeichensatz 'Diamond 12'
         *12         /
 Anleitung (Dir)     Enthält Die Anleitung in Form von Textdateien.
     Einleitung
     KapitelI
     KapitelII
     KapitelIII
     Anhang
*libs                Betriebssystem: Funktionsbibliotheken.
    *icon.library
    *diskfont.library


Auf Festplatte:

Das Programm "CoreWars" kann auf der Harddisk an einem beliebigen Platz
untergebracht werden. Es benötigt allerdings die unter 2.1 mit einem
Stern (*) bezeichneten Dateien in den entsprechenden Verzeichnissen.


Starten von Core Wars:

Core Wars kann von der Workbench durch die Maus oder vom CLI aus durch
den Befehl "run CoreWars" gestartet werden.



2.2 Eine erste Anwendung
________________________


Dieser und auch teilweise der nächste Abschnitt nehmen in der Anleitung
eine Sonderstellung ein.  Um die ersten in Kapitel eins behandelten
Beispielprogramme gegeneinander kämpfen zu lassen, müssen Sie sich hier
ein Grundwissen in der Bedienung von Core Wars aneignen.  Wenn sie
diesen Abschnitt durchgelesen haben, können Sie alle Kampfprogramme des
ersten Kapitels laufen lassen.  Um aber alle Fähigkeiten des Core Wars
Programmes ausnützen zu können, sollten Sie nach dem ersten Kapitel
wieder hier mit dem Lesen weiterfahren.


2.2.1 Die Menüs
---------------

Nachdem Core Wars gestartet ist, erscheint in der Mitte des hellgrauen
Hauptbildschirmes ein Textkasten.  Um ihn verschwinden zu lassen, können
Sie einfach mit der Maus irgendwo in diesen Kasten hineinklicken.  Nun
ist die Bahn frei für den ersten Kampf zwischen zwei Redcode-Programmen.
Am oberen Rand des Bilschirmes sehen Sie einen Titelbalken mit dem Namen
des Programmes.  Drücken Sie nun die rechte Maustaste und sehen Sie sich
die Menüpunkte an.  Ganz links haben wir unter "Amiga" den Menüpunkt
"Core Wars", hinter dem sich einige Infos zum Programm verstecken.

Der zweite Menustreifen enthält unter anderen die Punkte "Editor",
"Assembler" und "Kampf".  Mit dem Editor können Sie die Programmtexte
schreiben und verändern.  Diese Texte werden dann mit dem Assembler in
einen für MARS ausführbaren Code übersetzt (assembliert) und
schliesslich können diese übersetzten Programme mit dem Menüpunkt
"Kampf" gegeneinander antreten.

Hier sind die drei Punkte einer Redcode-Programmentwicklung aufgeführt:

1.   Das Programm wird wie ein normaler Text geschrieben und auf Diskette
     abgespeichert.  Dieser Text wird auch "Quelltext" oder "Quelldatei"
     genannt.

2.   Der Quelltext wird von einem Assembler in einen von MARS
     ausführbaren Code, den sogenannten "Objektcode" oder die "Objektdatei"
     verwandelt und dieser Code wird wiederum auf Diskette gespeichert.

3.   Zwei dieser Objektdateien werden schliesslich von MARS eingelesen
     und liefern sich dann ein Duell im Speicher von MARS.


2.2.2 Der erste Schritt: Ein Programm schreiben
-----------------------------------------------

Der Editor dient dazu, Programmmtexte zu schreiben und schon bestehende
Programmtexte zu verändern (editieren).  Anhand eines Beispieles sehen
Sie, wie ein schon bestehender Programmtext eingelesen und verändert
werden kann.

Bewegen Sie die Maus auf den Menüpunkt "Editor" und lassen Sie den
rechten Mausknopf los.  Augenblicklich erscheint ein neues Fenster und
in diesem Fenster heischt ein weisses Rechteck um ihre Aufmerksamkeit.
Dieses Rechteck wird Requester (englisch für Rückfrage) genannt und
dient dazu, den Namen eines Programmtextes einzugeben.  Klicken Sie mit
der Maus einmal in den schmalen, dunkleren Balken in diesem Rechteck.
Sie sehen, dass am linken Ende des Balkens ein kleines weisses Viereck
erscheint.  Dieses Viereck, der Cursor, zeigt Ihnen, an welcher Stelle
eines Textes sich der nächste Druck auf eine Taste auswirkt.  Tippen Sie
nun den Namen "Beispiele/Gnom" ein und klicken Sie mit der Maus in das
grüne Kästchen, das mit OK gekennzeichnet ist.  Der Computer sucht jetzt
im internen Laufwerk (df0:) nach einem Verzeichnis namens "Beispiele"
und dort nach einer Textdatei "Gnom".

Wenn Sie den Namen richtig eingegeben haben und wenn die verlangte Datei
wirklich auf der Diskette vorhanden war, wird der Programmtext nun
eingelesen.  Der Requester verschwindet und der Text wird angezeigt.
Wieder sehen Sie einen Cursor in Form eines kleinen weissen Vierecks
ganz links oben im Editorfenster.  Mit den vier Pfeiltasten können Sie
den Cursor in alle vier Himmelsrichtungen in Einzelschritten
verschieben.  Sobald Sie eine Buchstabentaste betätigen, erscheint das
entsprechende Zeichen an der Stelle, auf die der Cursor zeigt, das
Zeichen wird so in den Text eingefügt.  Wenn sich unter dem Cursor schon
ein Zeichen befand, werden dieses und alle noch in derselben Zeile
stehenden Zeichen nach rechts verschoben.

Eine andere Möglichkeit, den Cursor zu verschieben, besteht durch die
Maus.  Wenn Sie mit dem Mauszeiger auf eine beliebige Position im
angezeigten Text fahren und dann den linken Mausknopf drücken, wird der
Cursor unter den Mauszeiger gesetzt.  Sehr oft ist dies der einfachste
Weg, den Cursor auf ein bestimmtes Wort im Programmtext zu
positionieren.

Beim Redcode Editor handelt es sich um einen sogenannten "Full Screen -
Editor".  Das bedeutet, dass das Editorfenster nur einen Ausschnitt des
gesamten Textes anzeigt, der bis zu vierhundert Zeilen lang sein darf.
Probieren Sie folgendes aus: Zuerst laden Sie mit dem Menupunkt
"Einlesen" die Quelldatei "Gnom" im Verzeichnis "Beispiele" in den
Textspeicher.  Hängen Sie an diesen Text anschliessend einen anderen
Quelltext (z.B.  Mice) mit dem Menupunkt "Einfügen" an und wiederholen
den Vorgang einige Male.  Verschieben Sie nun den Cursor durch
wiederholtes Betätigen der Pfeiltasten nach unten.  Wenn Sie am unteren
Rand des Bildschirmes angekommen sind und Sie versuchen, den Cursor über
diesen Rand hinauszubewegen, so rollt der ganze Inhalt der Anzeige
Zeilenw eise durch das Editorfenster.  Stellen Sie sich das Ganze so
vor, als würden Sie über eine Seite eines Buches ein Blatt weisses
Papier mit einem kleinen rechteckigen Ausschnitt legen und dieses dann
nach oben oder unten verschieben.  Diese Verschiebung erfolgt bei
unserem Editor eben durch die Cursortasten oder, wie Sie später noch
sehen werden, durch verschiedene Kommandos, die es erlauben, sich unter
Anderem auch Seitenweise durch den Text zu bewegen.

Weitere gundlegende möglichkeiten, einen Programmtext zu verändern, sind
die Tasten "Delete" und "Backspace".  Diese dienen dazu, ein Zeichen
links oder direkt unter dem Cursor zu löschen.  "Delete" (beim Amiga
2000 und 500 die grosse Taste gleich links von der Help-Taste, beim
Amiga 1000 die Taste ganz rechts oben auf dem Zeichenblock) löscht das
Zeichen, das unmittelbar unter dem Cursor steht.  Wenn sich weiter
rechts mehrere Zeichen befinden, rücken alle weiteren um eine Stelle
nach links zum Cursor nach .  "Backspace" ist bei allen Amiga-Modellen
die Taste, die mit dem nach links weisenden Pfeil gekennzeichnet ist.
Beim Amiga 2000 und 500 befindet sie sich links von der Delete-Taste,
beim Amiga 1000 ist es die grosse Taste ganz rechts oben.  Probieren Sie
diese Tasten ruhig aus, indem Sie das Programm "Gnom" nach Ihrem
Gutdünken verändern.  Wenn Sie eine neue Zeile eines Textes eingetippt
haben, können Sie die RETURN-Taste drücken.  Der Cursor steht dann am
Beginn der nächsten Zeile.  Wenn sich der Cursor bei m RETURN mitten in
einer Zeile befand, werden die restlichen Zeichen auf die nächste Zeile
übernommen.  Diesen Vorgang können Sie durch drücken der
"Backspace"-Taste wieder rückgängig machen.

Eine kleine Exkursion mit der Maus im Menubalken fördert noch einige
Menupunkte mehr zutage.  Mit deren Hilfe können Sie bestimmte Wörter in
einem Text suchen und durch andere ersetzen, ganze Blöcke von Text
löschen und an einer anderen Ste lle wieder einfügen, die
Funktionstasten mit vielbenützten Wörtern belegen und vieles mehr.
Alle diese Möglichkeiten werden ausführlich im Abschnitt 2.3 (Schreiben
eines Kampfprogrammes) behandelt.

Natürlich sollten Sie noch wissen, wie Sie ein verändertes oder neu
geschriebenes Kampfprogramm wieder auf Diskette zurückspeichern können.
Im Menubalken finden Sie ganz links den Menustreifen "System" und in
diesem die Menupunkte "Abspeichern" und "Abspeichern als...".  Der
erste Menupunkt dient dazu, den Programmtext unter dem gleichen Namen,
mit dem er eingelesen wurde, wieder auf Diskette zu schreiben.  Aber
Vorsicht: Die alte Version des Programmtextes auf der Diskette mit
diesem Namen wird dabei überschrieben und geht somit verloren.

Der zweite Menupunkt, "Abspeichern als...", lässt das Abspeichern eines
Programmes unter einem neuen Namen zu.  Wählen Sie diesen Menupunkt
probehalber einmal an.  Wie beim Starten des Editors erscheint wieder
ein Rückfragekasten, der Sie um einen Dateinam en bittet.  Klicken Sie
wieder in den Textbalken und geben Sie einen neuen Namen ein, z.  B.
"Beispiele/MeinGnom".  Im Verzeichnis "Beispiele" auf der internen
Diskette befindet sich nun eine neue Textdatei mit diesem Namen.  Auch
sie kann wieder eingelesen, verändert und abgespeichert werden.

Noch eine Bemerkung zum Editor: Sie können durch ihn beliebige
Programmtexte verändern, also auch alle Redcode Quelldateien, die im
Verzeichnis "Beispiele" vorhanden sind.  Wir haben vorhin ein solches
Beispielprogramm eingelesen: "Gnom".  Wenn Sie wie emp fohlen einige
Experimente angestellt haben, sollten Sie den "Gnom" auf keinen Fall
wieder unter dem gleichen Namen abspeichern, weil sonst das
ursprüngliche (und funktionsfähige) Programm verlorengeht.

Wenn Sie den Editor nach getaner Arbeit wieder verlassen wollen, wählen
Sie im Menustreifen "System" den Punkt "Abbrechen" an.  Der Menubalken
des Editors wird wieder durch den des Core Wars Programmes ersetzt und
der Bildschirm erstrahlt in seinem gewohnten Grau.


2.2.3 Der zweite Schritt: Einen Programmtext assemblieren
---------------------------------------------------------

Während der Lektüre des ersten Kapitels werden Sie schon Ihre ersten
Kampfprogramme schreiben.  Um diese dann auch gegeneinander kämpfen zu
lassen, müssen sie in einer für das MARS verständlichen Form vorliegen -
die Programmtexte müssen assembliert oder übersetzt werden.  Unser
Beispiel "Gnom" liegt zwar schon in assemblierter Form vor, aber wir
werden den Vorgang jetzt nochmals nachvollziehen.

Wählen Sie im Menubalken von Core Wars unter "Action" den Menupunkt
"Assembler" an.  Ein Requester ähnlich dem, der Sie schon beim Editor
kennengelernt haben, fragt nach dem Namen des Programmtextes.  Klicken
Sie wie gehabt mit der Maus in den schmalen Textbalken und geben Sie
"Beispiele/Gnom" ein.  Jetzt können Sie entweder mit der Maus in das
grüne OK-Kästchen (auch Gadget genannt) klicken oder einfach die
Return-Taste betätigen.  Wenn der Text auf der Diskette gefunden wurde,
erscheinen in kurzen Abständen Kommentare in Form von Textzeilen auf dem
Bildschirm.  Diese Zeilen teilen Ihnen mit, was der Assembler im
Augenblick mit dem Programmtext anstellt und sie können zur Fehlersuche
in einem eigenen Programm recht hilfreich sein.

Es wird vor allem bei Ihren ersten eigenen Programmen selten vorkommen,
dass Ihr Programmtext gleich auf Anhieb fehlerfrei übersetzt wird.  Wenn
der Assembler ein Programm nicht übersetzen kann, wird der Vorgang der
Assemblierens sofort abgebrochen und in der Mitte des Bildschirmes wird
ein Textkasten angezeigt, der Ihnen beschreibt, in welcher Zeile des
Programmes welcher Fehler aufgetreten ist.  In diesem Fall bleibt nur
noch eins: Editor starten und den Fehler korrigieren.  Hilfestellung bei
der Fehlersuche leistet Ihnen der Abschnitt 2.9, "Fehlermeldungen des
Assemblers".

Wenn der Programmtext erfolgreich übersetzt wurde, verlangt wiederum ein
Requester die Eingabe eines Namens, unter dem der auf MARS lauffähige
Programmcode auf Diskette gespeichert werden soll.  Haben Sie es
bemerkt? Der beim Einlesen des Programmtextes verwendete Namen bleibt
erhalten und an den ursprünglichen Namen wurde die Endung '.prg'
angehängt.  Diese Endung dient dazu, einen Programmtext von einem
lauffähigen Kampfprogramm, dem Objektcode, zu unterscheiden.  Sie können
natürlich einen ganz anderen Namen für das übersetzte Programm
verwendet, indem Sie einfach den angebotenen Namen verändern.  So ist
auch die Endung '.prg' nicht zwingend, Sie können beispielsweise ihre
Objektdateien alle mit der Endung '.obj' abspeichern, um sie zu
unterscheiden.  Klicken Sie nun mit der Maus in das grüne OK-Kästchen,
damit das übersetzte Programm auf die Diskette geschrieben wird.


2.2.4 Der erste Kampf
---------------------

Die übersetzten Programme müssen nun ihre Feuerprobe bestehen: können
sie sich im direkten Kampf gegen andere Redcodeprogramme behaupten? Die
Antwort erhalten Sie durch das Herz des Core Wars Programmes, MARS.

Wir werden als erstes zwei typische Redcodeprogramme gegeneinander
antreten lassen: "Gnom" und "Knirps".  Schalten Sie dazu die Optionen
"Trace" (Zeitlupe) und "Status" (verschiedene Statusanzeigen) aus, weil
diese den Kampf zwischen den Programmen unnöti g in die Länge ziehen
würden.  Dies erreichen Sie, indem Sie im Menustreifen "Optionen" die
Menupunkte "Trace" und "Status" je einmal anwählen.  Dadurch
verschwinden die Haken, die vor den Menupunkten standen und anzeigten,
dass die beiden Optionen eingesch altet waren.  Die Option "Grafik"
sollte aber aktiviert bleiben, weil sie den gesamten MARS-Speicher auf
einmal auf dem Bildschirm darstellt.

Wenn Sie dies erledigt haben, können Sie im Menustreifen "Action" den
Punkt "Kampf" anwählen.  In der Mitte des Bildschirmes erscheint ein
grosser Requester mit zwei Textbalken.  Geben Sie in diese beiden Balken
je einen der Programmnamen ein, in den ersten "Beispiele/Gnom.prg" und
in den Zweiten "Beispiele/Knirps.prg".  Anschliessend klicken Sie mit
der Maus in das grüne OK-Kästchen rechts unten im Requester, um die
Eingaben abzuschliessen und den Kampf zu beginnen.

Die zwei Kampfprogramme werden eingelesen und auf dem Bildschirm tritt
die Grafikanzeige in Aktion.  Sie besteht aus einem grossen, anfänglich
schwarzen Fenster mit dem Titel "Core Wars - Grafik".  Die schwarze
Fläche dieses Fensters stellt den gesamten MARS-Speicher von 8000 Zellen
auf einmal dar.  Jede Zelle wird durch einen kleinen, länglichen Punkt
in diesem Fenster repräsentiert.  An den letzten Punkt der untersten
Zeile des Grafikfensters schliesst sich in Gedanken der erste Punkt der
obersten Zeile an, analog der ringförmigen Struktur des MARS
Speicherfeldes.  Die Punkte können vier verschiedene Farben annehmen,
die zeigen, was mit der entsprechenden Speicherzelle im Augenblick
geschieht.  Diese Farben sind rot, grün, hellrot und hellgrün.  Sie
werden es schon erraten haben: Rote und grüne Farbtöne stehen jeweils
für ein Programm.  Links und rechts oben auf dem Bildschirm stehen
übrigens die Namen der Programme in ihrer Farbe, in der sie in der
Speichergrafik erscheinen. Falls sie nur 512 KByte Speicher haben, kann
es vorkommen, dass die Namen nicht hingeschrieben werden. Für diesen
Fall ist es wichtig zu wissen, dass das im oberen Textbalken des
Requesters eingegebene Programm die grünen Farbtöne hat, das zweite
also die roten.

Ein roter Punkt auf der Anzeige bedeutet, dass ein Programmbefehl des
roten (rechten) Programmes diese Speicherzelle verändert hat.  Dies kann
durch einen der Redcode-Befehle MOV, ADD, SUB oder DJN geschehen.  Ein
hellroter Punkt bezeichnet die Programmzei len, die schon von einem
Programmzeiger bearbeitet worden sind.  Gleiches gilt auch für das grüne
Programm, dessen Namen auf der linken Seite des Bildschirmes angezeigt
wird.  So können Sie unterscheiden, welche Zellen von Ihrem Programm
verändert wurden und wo sich der Programmzeiger gerade befindet.  Es ist
faszinierend, einem solchen Kampf zweier Programme zuzusehen.  Durch die
visuelle Umsetzung des Geschehens im Speicher kann man den Verlauf der
Schlacht hautnah miterleben.  Vor dem schwarzen Hintergrund der noch
unveränderten Speicherzellen wälzt sich "Knirps", einen hellroten
Streifen von bearbeiteten Zellen hinterlassend, mit hoher
Geschwindigkeit durch den Speicher.  Gleichzeitig beginnt "Gnom" mit der
systematischen Bombardierung des Spielfeldes mit DAT 0 - Bomben.  Wer
wird den Kampf gewinnen? Wenn "Gnom" mit seinem Granatfeuer "Knirps"
erreichen kann, bevor er selbst von "Knirps" überrollt wird, ist das
Duell zu seinen Gunsten entschieden.  Sollte umgekehrt "Gnom" von
"Knirps" zuerst getroffen werden, stehen die Chancen gut für "Knirps",
der auf diese Weise ein Unentschieden herausholen kann.  Damit haben Sie
diese Einführung ins Core Wars System erfolgreich gemeistert und können
mit dem Lesen im ersten Kapitel weiterfahren.  Scheuen Sie sich nicht,
Core Wars auf Herz und Nieren auszuprobieren, wann immer Sie ein neues
Kampfprogramm testen wollen.




2.3 Schreiben eines Kampfprogrammes
___________________________________



In diesem Abschnitt werden zwei verschiedene Themen behandelt: Wir
machen Sie zum Einen mit der Bedienung des Core Wars Editors vertraut
und wir zeigen Ihnen zum Andern, welche Grundsätze Sie beachten müssen,
wenn Sie ein Redcodeprogramm schreiben wollen.  Im Gegensatz zu
Abschnitt 2.2 ("Eine erste Anwendung"), das nur einen groben Ueberblick
zu Core Wars bot, werden ab jetzt alle Funktionen und Möglichkeiten des
Systems erschöpfend beschrieben.


2.3.1 Der Editor
----------------

Der Redcode Editor wird vom Core Wars Programm aus durch den Menupunkt
"Editor" im Streifen "Action" aufgerufen.  Er ist dazu vorgesehen, den
Programmtext eines Redcodeprogrammes einfach und schnell zu erstellen.
Dennoch bietet dieser Editor eine Fülle von nützlichen Funktionen,
angefangen vom Einlesen und Abspeichern von Text bis zur Belegung von
Funktionstasten mit beliebigen Floskeln.  Alle diese Funktionen können
sowohl mit der Maus durch die Menustreifen als auch durch spezielle
Tastenkombinationen aufgerufen werden.  Die folgenden Absätze führen Sie
zunächst durch die einfachsten Grundlagen das Editors, um dann nach und
nach auch die komplizierteren Möglichkeiten zu beleuchten.


2.3.2 Bildschirmaufbau des Editors
----------------------------------

Das Hauptgeschehen im Editor spielt sich im grossen, fast den ganzen
Bildschirm umfassenden Textfenster ab.  Dort wird der eingelesene Text
angezeigt und dort können Sie Ihre Programme eingeben.  Von diesem
Textfenster wird durch eine dünne Linie eine einzelne Zeile abgetrennt,
die Statuszeile.  In dieser Zeile werden verschiedene Meldungen des
Editors angezeigt.  Wenn Sie eine Funktion falsch anwenden, erscheint
dort eine entsprechende Fehlermeldung.  Die Statuszeile dient ebenfalls
zur Eingabe von einfachen Zahlenwerten, die der Editor benötigt: Ein
Beispiel ist die Grösse des Tabulatorsprunges, die Sie ändern können.
Normalerweise wird in der Statuszeile jedoch immer der Name der gerade
bearbeiteten Quelldatei angezeigt.


2.3.3 Bewegen im Text
---------------------

Die einfachsten Möglichkeiten, sich mit dem Editor durch einen Text zu
bewegen, haben Sie schon kennengelernt: Die Cursortasten dienen dazu,
jeweils um ein Zeichen oder eine Zeile nach links, rechts, oben oder
unten zu hüpfen.  Der Redcode Editor bietet jedoch noch mehr
Steuerfunktionen, die alle bei der Behandlung der Menustreifen etwas
weiter unten erklärt werden.


2.3.4 Die Menustreifen
----------------------

Nach dem Aufrufen des Editors werden die Menustreifen des Core Wars
Hauptprogrammes durch diejenigen des Editors ersetzt.  Die folgenden
Menustreifen werden aktiv und können mit der Maus angewählt werden:

     SYSTEM         Alle Operationen, die sich auf Diskette oder den
                    ganzen Programmtext beziehen.
     EDITIEREN        Die Mehrzahl der Kommandos, durch die sich der
                    Programmtext verändern lässt.
     REDCODE        Redcode-Spezifische Funktionen.
     BEWEGEN        Alle Kommandos, die es erlauben, sich im Text zu
                    bewegen und ihn auf dem Bildschirm anzuzeigen.
     SUCHEN         Funktionen, mit denen sich nach bestimmten Wörtern
                    oder Sätzen im Text suchen lässt.
     SPEZIAL        Einige weitere Funktionen, bei denen es
                    schwerfällt, sie in den vorangegangenen
                    Sammelbegriffen einzuordnen.

Es folgt nun eine genaue Beschreibung jedes Menupunktes dieser
Menustreifen.  Die Ueberschrift der einzelnen Absätze entspricht dem
Namen des Streifens, gefolgt von einem Schrägstrich und dem Namen des
Menupunktes.  Hinter dem Titel folgt die Tastenkombination, mit der die
Funktion ebenfalls aufrufbar ist.  Die Tasten werden mit folgenden
Kürzeln bezeichnet:

o    ESC            Escape-Taste. Diese Taste braucht im Gegensatz zu
                    den anderen Steuertasten nicht gleichzeitig mit
                    der Buchstabentaste gedrückt zu werden. Als
                    Gedankenstütze erscheint in der Statuszeile die
                    Meldung "Befehlsmodus".
o    AMIGA          Die rechte Amiga-Taste, gleich rechts neben der
                    Leerschlag-Taste.
o    SHIFT          Die Shift- oder Zweitfunktionstaste. Die Amiga-
                    und die Shift-Tasten müssen gleichzeitig mit dem
                    entsprechenden Buchstaben oder Pfeil gedrückt
                    werden.
o    TAB            Die Tabulatortaste. Sie liegt im linken oberen
                    Teil der Tastatur gleich unterhalb der Escape-Taste.
o    <u>            Pfeil nach unten.
o    <o>            Pfeil nach oben.
o    <l>            Pfeil nach links.
o    <r>            Pfeil nach rechts.
o    a...z          Die Zeichentasten der Tastatur klein...
o    A...Z          oder gross (mit der Shift-Taste gleichzeitig).

Lesen Sie die Erklärungen der Reihe nach durch und führen Sie die
aufgeführten Menupunkte gleich aus.  Wenn Sie später während der Arbeit
mit dem Editor bei der einen oder anderen Funktion nicht mehr wissen,
wie sie angewendet wird, können Sie die benötigten Informationen hier
sehr leicht finden.


System/Einlesen (AMIGA r)
-------------------------

Liest eine Quelldatei von Diskette, Festplatte oder RAM-Disk in den
Editorspeicher ein.  Wenn sich schon ein Text im Editor befindet, so
wird dieser durch den eingelesenen Text überschrieben.  Der Name der
Datei kann durch einen Textkasten, der auf dem Bildschirm erscheint,
eingegeben werden.  Nach der Eingabe muss entweder die Return-Taste
gedrückt oder eines der beiden Antwortkästchen mit der Maus angeklickt
werden: OK = Einlesen oder ABBRUCH = Abbrechen des Vorgangs.  Nach einem
Abbruch ist der alte Quell text unverändert im Editorspeicher vorhanden.


System/Abspeichern (AMIGA s)
----------------------------

Der Text im Editorspeicher wird unter dem aktuellen Namen in den
Massenspeicher (Diskette, Festplatte oder RAM-Disk) zurückgespeichert.
Eine alte Datei mit dem gleichen Namen wird dabei durch den neuen Text
überschrieben.  Der aktuelle Name wird normalerweise in der Statuszeile
laufend angezeigt.


System/Abspeichern als (AMIGA v)
--------------------------------

Schreibt den Text, der sich im Editorspeicher befindet, unter einem
neuen Namen auf den Massenspeicher.  Der Name kann durch den bekannten
Eingabekasten gewählt werden.  Der Vorgang kann natürlich wieder durch
Anklicken von ABBRUCH abgebrochen oder durch Anklicken von OK bestätigt
werden.  Wenn sich eine Datei mit dem gleichen Namen, den Sie eingegeben
haben, schon auf der Diskette befindet, wird diese durch den neuen Text
überschrieben.


System/Einstellungen l. (AMIGA l)
---------------------------------

Der Redcode Editor bietet die Möglichkeit, bestimmte Einstellungen des
Editors auf Diskette zu speichern und wieder einzulesen.  Diese
Einstellungen sind:

a)   Der Tabulatorsprung, also die Anzahl der Zeichen, die übersprungen
     werden, wenn die Tabulatortaste gedrückt wird.
b)   Die Unterscheidung von Gross/Kleinschrift beim Suchen von Wörtern.
c)   Das Aufblitzen des Bildschirms, wenn über das 66-ste Zeichen
     hinweggeschrieben wird.
d)   Alle Makros, die Sie selbst eingegeben haben. Was Makros sind und
     wie Sie diese verändern können, erfahren Sie bei der Funktion
     "Spezial/Makros eingeben".

Alle diese Einstellungen können Sie nach Ihrem Geschmack verändern und
dann auf Diskette abspeichern.  Wenn Sie den Editor ein anderes Mal
wieder starten, können Sie Ihre Einstellungen schnell wieder von der
Diskette einlesen, um sich in Ihren bevorzugten Modi zu befinden.

Bei dieser Funktion steht das kleine "l" für "lesen", es werden also
Einstellungen eingelesen.  Sie können den Namen der Einstellungen wie
beim Einlesen einer normalen Textdatei durch den Eingabekasten wählen.

Wenn der Editor zum ersten Mal aufgerufen wird, versucht er, eine Datei
mit Standardeinstellungen einzulesen.  Diese Datei muss im Verzeichnis
"System" mit dem Namen "Einstellungen" auf der Core Wars Diskette
vorhanden sein.  Sie können also Ihre eigenen Einstellungen unter dem
Namen ":System/Einstellungen" abspeichern.  Von diesem Zeitpunkt an
werden bei jedem Neustart des Core Wars Programmes Ihre bevorzugten
Einstellungen automatisch eingelesen.


System/Einstellungen s. (AMIGA e)
---------------------------------

Hier werden die Einstellungen auf Diskette gesichert (s = sichern).  Der
Editor verlangt wiederum einen Namen, unter dem die Einstellungen
abgespeichert werden können.

Wir empfehlen, dass Sie den oder die Namen ihrer Einstellungen so
wählen, dass er nicht mit dem einer normalen Quelldatei eines
Redcode-Programmes verwechselt werden kann.  Ein Beispiel wäre, für
Einstellungen immer die Endung ".MOD" für Modus am Namen anzuhängen.


System/Einfügen (AMIGA i)
-------------------------

Gleich wie bei der Funktion "System/Einlesen" wird hier eine Quelldatei
von Diskette in den Editorspeicher eingelesen.  Ein schon im Editor
vorhandener Quelltext geht jedoch nicht verloren, sondern der neue Text
wird an der Position des Cursors in den alten eingefügt.  Auf diese
Weise können Sie mehrere kleine Programme zu einem grösseren
zusammenfassen.  Beispiel für ein grosses Programm, das eigentlich aus
mehreren kleinen aufgebaut wurde, ist der "Fallensteller", der in
Kapitel 3.2 näher erklärt wird.


System/Name ändern (AMIGA a)
----------------------------

Sie können hier den Namen einer bereits eingelesenen oder neu
geschriebenen Datei ändern.  Der neue Name wird wie immer durch einen
Eingabekasten gewählt und erscheint darauf in der Statuszeile des
Editors.


System/Nochmals laden (AMIGA n)
-------------------------------

Wenn Sie nach vielen Aenderungen eines Quelltextes merken, dass die
ursprüngliche Version doch um einiges besser war, können Sie mit dieser
Funktion die alte Quelldatei nochmals von Diskette einlesen.  Beachten
Sie jedoch, dass alle Veränderungen des Text es im Editorspeicher dabei
verloren gehen.


System/Abbrechen (AMIGA q)
--------------------------

Nichts geheimnisvolles: Der Editor wird beendet und Sie befinden sich
wieder im Hauptprogramm von Core Wars. Wenn der Editor später wieder
aufgerufen wird, ist der zuletzt editierte Programmtext noch vorhanden.


Editieren/Marke setzen (AMIGA m)
--------------------------------

Wie viele Textverarbeitungen bietet auch der Redcode Editor verschiedene
Funktionen an, mit deren Hilfe beliebige Textblöcke ausgeschnitten und
an anderer Stelle wieder in den Text eingefügt werden können.  Diese
Funktionen benötigen die Position und die Grösse des Blockes, der
bearbeitet werden soll.  Wir haben dieses Problem so gelöst, dass wir
den Block durch zwei Punkte begrenzen, die an beliebiger Position im
Text stehen können.  Der eine dieser Punkte ist die augenblickliche
Cursorposition, der andere Punkt ist die Marke.  Sehen wir uns den
folgenden Ausschnitt aus einem Redcode-Quelltext an, um die Bedeutung
des Cursors und der Marke zu verdeutlichen:

                    DAT 0          ; Zeiger auf Quelle
                    DAT 99         ; Zeiger auf Ziel, 100 Zellen
          start     MOV @-2, @-1   ; Quelle zum Ziel kopieren
                    CMP -3, #9     ; Ist das ganze Programm kopiert?
                    JMP ende       ; Ja: Schleife beenden
                    ADD #1, -5     ; sonst die beiden Zeiger
                    ADD #1, -5     ; inkrementieren
                    JMP start      ; Schleife wiederholen
          ende      MOV #99, 93    ; Programmkopie beenden
                    JMP 93         ; und dorthin springen.

Der Cursor ist auf dem "i" des Wortes "Zeiger" in der zweiten Zeile
positioniert, die Marke steht auf dem "n" des Wortes "ende" in der
fünften Zeile.  Der Block, der durch diese zwei Punkte begrenzt ist,
sieht so aus:

iger auf Ziel, 100 Zellen
          start     MOV @-2, @-1   ; Quelle zum Ziel kopieren
                    CMP -3, #9     ; Ist das ganze Programm kopiert?
            JMP e

Dabei ist es unwichtig, ob der Cursor oder die Marke den Beginn des
Blockes kennzeichnet.  Auch wenn die Marke auf dem "i" und der Cursor
auf dem "n" gelegen hätte, wäre der Inhalt des Blockes derselbe
geblieben.

Alle Blockfunktionen beziehen sich auf den ganzen Block inklusive des
Zeichens, auf dem die obere der beiden Markierungen steht.  Der Redcode
Editor unterstützt diese Manipulationen mit Blöcken:


Editieren/Schneiden (AMIGA x)
-----------------------------

Legt den durch Marke/Cursor bezeichneten Textblock im Puffer ab und
löscht anschliessend diesen Block aus dem Text.  Der alte Inhalt des
Puffers geht verloren, weil er durch den neuen Block ersetzt wird.


Editieren/Löschen (AMIGA d)
---------------------------

Löscht den durch Marke/Cursor bezeichneten Textblock aus dem
Editorspeicher.  Der Puffer wird nicht verändert.


Editieren/Kopieren (AMIGA c)
----------------------------

Kopiert den durch Marke/Cursor bezeichneten Textblock in den Puffer.
Der aktuelle Text wird nicht beeinflusst, der alte Inhalt der Puffers
wird jedoch überschrieben.


Editieren/Einfügen (AMIGA p)
----------------------------

Der gesamte Puffer wird an der durch den Cursor bestimmten Position im
Text eingefügt.  Alle folgenden Textzeilen werden um entsprechend viele
Zeilen nach unten verschoben.

Wenn ein neuer Text eingelesen wird, wird der Editorspeicher
überschrieben.  Die Daten, die im Puffer stehen, werden jedoch erhalten
und können weiterverwendet werden.  Sie können so zum Beispiel ein
Programm schreiben und durch "kopieren" von Zeit zu Zeit im Puffer
ablegen.  Wenn Sie nach einigen Veränderungen dann merken, dass die
zuletzt im Puffer abgelegte Version des Programmes doch etwas besser
war, können Sie den aktuellen Text löschen (nicht schneiden!) und mit
"einfügen" den Quelltext im Puffer wie der hervorholen.

Inzwischen sollte die Bedeutung von "Marke setzen" etwas
offensichtlicher sein: An der Cursorposition wird die Marke gesetzt.
Die Marke ist jedoch auf dem Bildschirm im Gegensatz zum Cursor nicht
sichtbar.  Sie sollten sich deshalb immer im Klaren darüber sein, an
welcher Position sie das letzte Mal die Marke gesetzt haben.  Nach einem
Neustart von Core Wars und dem Editor zeigt die Marke automatisch auf
das erste Zeichen der ersten Zeile.  Es ist wichtig, dies zu wissen,
weil Sie sonst unbeabsichtigt grössere Teile des Quelltextes löschen
könnten.


Editieren/Text neu (ESC c)
--------------------------

Löscht den gesamten Text aus dem Editorspeicher.  Der Puffer wird nicht
beeinflusst und der Name der Quelldatei sowie alle Einstellungen bleiben
ebenfalls erhalten.  Um die unbeabsichtigte Löschung eines Textes zu
verhindern, haben wir eine Sicherheitsabfrage eingebaut.  In der Mitte
des Editorfensters erscheint ein weisser Textkasten mit der Frage, ob
wirklich gelöscht werden soll.  Sie können hier den Vorgang abbrechen,
indem Sie mit der Maus in das ABBRUCH-Kästchen klicken.


Editieren/Alles löschen (ESC r)
-------------------------------

Wie bei "Text neu" wird auch hier der gesamte Text gelöscht.  Darüber
hinaus werden alle Einstellungen auf die Standardwerte gesetzt und der
Puffer wird ebenfalls gelöscht.  Auch hier findet zuvor eine
Sicherheitsabfrage nach dem gleichen Prinzip wie bei " Text neu" statt.


Editieren/Löschen Ende (ESC e)
------------------------------

Von der aktuellen Cursorposition bis zum Ende des Textes wird alles
gelöscht, wobei der Puffer nicht verändert wird.  Diese Funktion ist
jedoch mit Vorsicht zu geniessen, weil keine Sicherheitsabfrage
vorgenommen wird.


Editieren/Löschen Anfang (ESC a)
--------------------------------

Der Text wird vom Beginn bis zur aktuellen Cursorposition gelöscht.
Alles weitere ist gleich wie bei "Löschen Ende".


Editieren/Zeile löschen (ESC k)
-------------------------------

Die Zeile, in der sich der Cursor befindet, wird ganz gelöscht.  Alle
nachfolgenden Zeilen des Textes rücken um eine Stelle nach oben.


Editieren/Lösch. ab Cursor (ESC l)
----------------------------------

Von der aktuellen Cursorposition bis zum Ende der Zeile werden alle
Zeichen gelöscht.  Die folgenden Zeilen werden nicht verschoben, der
Platz der gelöschten Zeichen bleibt erhalten.


Editieren/nächstes Wort l. (AMIGA o)
------------------------------------

Das nächste Wort, das in seiner ganzen Länge rechts vom Cursor liegt,
wird aus dem Text gelöscht.


Editieren/voriges Wort l. (AMIGA k)
-----------------------------------

Das nächste Wort, das noch ganz links des Cursors liegt, wird aus dem
Text gelöscht.


Editieren/Wort gross (AMIGA g)
------------------------------

Das Wort, in dem der Cursor positioniert ist, wird ganz in
Grossbuchstaben geschrieben.  Buchstaben, die schon vorher gross
geschrieben waren, bleiben unverändert.  Diese Funktion ist nützlich,
wenn ein Redcode-Befehl aus Versehen klein geschrieben wurde und nun in
Grossschrift dastehen sollte.  Wenn der Cursor beim Aufrufen der
Funktion nicht innerhalb eines Wortes stand, wird der Text nicht
verändert.


Redcode/DAT, MOV, ADD, SUB, JMP, JMZ, JMN, DJN, CMP, SPL (F1 ...)
-----------------------------------------------------------------

Dies sind eigentlich ziemlich triviale, aber dennoch sehr nützliche
Funktionen.  Sie tun nichts anderes, als die Zeichen des entsprechenden
Befehles an der aktuellen Cursorposition in den Programmtext einzufügen.
Am Ende des eingesetzten Befehls wird noch ein Zwischenraum angehängt
und der Cursor wird auf das folgende Zeichen gesetzt.  Alle diese
Menupunkte können auch durch die Funktionstasten F1 bis F10 (die oberste
Reihe der Tastatur) aufgerufen werden.  Dabei steht F1 für den Befehl
"DAT", F2 für "MOV" und so weiter bis zu F10 für "SPL".  Mit dem
Menupunkt "Makro Eingeben" kann die Belegung der Funktionstasten mit
Wörtern beliebig verändert werden.


Redcode/Formatieren
-------------------

Nach dem Aufruf wird der gesamte Quelltext im Editorspeicher nach einem
bestimmten Schema formatiert.  Es werden alle Redcode-Befehle in
Grosschrift umgewandelt und bündig untereinander geschrieben.  Alle
Leerzeichen zwischen den Argumenten der Redcode-Befehle werden auf ein
Komma mit einem folgenden Leerzeichen reduziert.  Die Kommentare werden
gleich wie die Befehle untereinander ausgerichtet und in die richtige
Spalte geschrieben.  Hier ist das Schema, nach dem die Zeilen formatiert
werden:


"Label Opcode Argument A, Argument B ; Kommentar" = Eine Zeile Quelltext.


Label:              16 Zeichen
Opcode:             4 Zeichen
Argumente A + B:    19 Zeichen zusammen. Die Argumente müssen durch ein
                    Komma getrennt sein. An das Komma wird immer genau
                    ein Leerzeichen angehängt. Das Komma kann weggelassen
                    werden, wenn nur ein Argument angegeben wird.
Kommentar:          38 Zeichen. Alle überschüssigen Zeichen werden
                    abgeschnitten und gehen verloren.

Durch diese Formatier-Funktion wird das Schreiben eines
Redcode-Programmes sehr vereinfacht.  Es müssen keine festen Abstände
eingehalten werden, die Befehle können klein geschrieben werden und die
Kommentare können gleich anschliessend an die Argumente getippt werden.
Eine der wenigen Bedingungen für eine richtige Formatierung ist, dass
Sie einen Redcode-Befehl nicht in der vordersten Spalte einer Zeile
beginnen dürfen.  Wörter, die am linken Rand einer Zeile anfangen,
werden als Labels angesehen.  Lassen Sie deshalb mindestens ein
Leerzeichen stehen, bevor Sie das Befehlswort schreiben.  Gleiches gilt
für die Trennung zwischen Befehlen und Argumenten, auch hier ist
mindestens ein Leerzeichen nötig.


Redcode/Syntax prüfen
---------------------

Dies ist eine der speziell auf das Schreiben von Redcode Programmen
zugeschnittenen Funktionen dieses Editors.  Die Funktion überprüft
beginnend mit der ersten Zeile des Programmtextes im Editorspeicher den
Aufbau des Redcode-Programmes auf Syntaxfehler.  Folgendes wird
kontrolliert:

     o    Die Befehle müssen mit Grossbuchstaben geschrieben sein.
     o    Jede Zeile ausser den reinen Kommentarzeilen muss genau einen
          gültigen Befehl enthalten.
     o    Nach den Argumenten dürfen ausser den Kommentaren keine
          Zeichen mehr folgen.
     o    Jedes Label darf nur einmal definiert werden (oder mit
          anderen Worten am linken Rand der Zeile stehen).
     o    Die Anzahl der Argumente für jeden Befehl muss stimmen.
     o    Die Adressierung der Argumente muss erlaubt sein (siehe
          Befehlsliste in Abschnitt 4 des ersten Kapitels).

Sobald ein Fehler auftritt, wird der Cursor auf die entsprechende Stelle
im Text gesetzt und in der Statuszeile wird die Art des Fehlers
angezeigt.  Sie können nun den Fehler korrigieren und danach erneut die
Funktion "Syntax prüfen" aufrufen.  Wenn Sie auf diese Weise einen
Quelltext durchgearbeitet haben, sollte eigentlich keiner der üblichen
Syntaxfehler mehr im Programm sein.  Natürlich ist es möglich, dass sich
noch logische Fehler in Ihrem Quelltext verbergen.  Diese können Sie
dann erst nach dem Assemblieren durch einen Probelauf mit den "Trace"-
und "Status"- Optionen entdecken (siehe Abschnitte 2.6 bis 2.8).

Vor dem Aufruf von "Syntax prüfen" sollte das Programm üblicherweise mit
"Formatieren" etwas auf Vordermann gebracht werden.  Die
offensichtlichsten Fehler findet man nämlich meistens schon dann, wenn
ein Quelltext einigermassen geordnet aussieht.  Weitere Informationen
zum Thema Fehlersuche können Sie den Abschnitten 2.9 und 2.10 entnehmen.


Bewegen/Textanfang (ESC <o>)
----------------------------

Alle Funktionen im Menustreifen "Bewegen" dienen dazu, den Cursor im
Text zu positionieren.  Besondere Beachtung verdienen hier "vorige
Seite" und "nächste Seite".  Diese Kommandos können nämlich auch durch
einen Mausklick in den Titelbalken bzw.  in die Statuszeile des Editors
augerufen werden.  Doch gehen wir die Menupunkte der Reihe nach durch:
"Textanfang" bewegt den Cursor auf das erste Zeichen des Textes.  Das
Editorfenster wird neu aufgebaut, wenn sich der Beginn des Textes nicht
in der Anzeige befindet.


Bewegen/Textende (ESC <u>)
--------------------------

Der Cursor wird auf das letzte Zeichen des Textes gesetzt.  Wiederum ist
es möglich, dass der Bildschirm neu aufgebaut wird.


Bewegen/Zeile... (ESC g)
------------------------

Diese Funktion bewegt den Cursor auf den Beginn einer Zeile, die Sie
durch ihre Nummer bestimmen können.  In der Statuszeile erscheint eine
Aufforderung, die Nummer der Zeile einzugeben.  Wenn Sie eine Zahl
verwenden, die auf eine Position ausserhalb des Textes weist, wird in
der Statuszeile eine Fehlermeldung angezeigt und Sie befinden sich
wieder im normalen Editorfenster.  Die Zahl kann mit den normalen
Zahlentasten eingegeben und gegebenenfalls mit der "Backspace"-Taste
korrigiert werden.  Die Eingabe der Zahl wird durch einen Druck auf die
RETURN-Taste abgeschlossen.


Bewegen/Marke tauschen (ESC t)
------------------------------

Die aktuelle Cursorposition wird mit der Position der Marke (siehe
Blockfunktionen, Menu "Editieren") vertauscht.  Eventuell wird dabei der
Bildschirm neu aufgebaut, wenn die Marke ausserhalb des Editorfensters
lag.  Die Marke zeigt anschliessend an die Stelle, an der sich zuvor der
Cursor befand.  Denken Sie daran, dass die Marke nach einem Neustart des
Systems immer auf das erste Zeichen der ersten Zeile zeigt.


Bewegen/nächste Seite (ESC n)
-----------------------------

Im Editorfenster wird die nächste Seite des Textes angezeigt und der
Cursor auf das erste Zeichen der untersten Bildschirmzeile gesetzt.
Wenn Sie am Ende des Editorspeichers angekommen sind, erscheint die
letzte Textlinie auf der letzten Zeile des Bildschirms.  Diese Funktion
kann auch dadurch aufgerufen werden, indem Sie mit der Maus in die
Statuszeile des Editors klicken.


Bewegen/vorige Seite (ESC v)
----------------------------

Die vorhergehende Seite im Text wird im Editorfenster angezeigt.  Der
Cursor erscheint auf dem ersten Zeichen der obersten Bildschirmzeile.
Analog zur Funktion "nächste Seite" wird beim Erreichen des Textbeginns
die erste Linie des Textes in der obersten Bildschirmzeile angezeigt.
Auch hier kann die Funktion durch Klicken mit der Maus in den
Titelbalken des Editorfensters aufgerufen werden.


Bewegen/nächstes Wort (SHIFT <r>)
---------------------------------

Der Cursor wird auf das erste Zeichen des nächsten, ganz rechts von der
aktuellen Cursorposition stehenden Wortes bewegt.  Wenn auf der selben
Zeile kein weiteres Wort mehr zu finden ist, springt der Cursor auf den
Beginn der nächsten Linie.


Bewegen/voriges Wort (SHIFT <l>)
--------------------------------

Hier wird der Cursor auf das letzte Zeichen des nächsten, ganz links von
der aktuellen Cursorposition stehenden Wortes bewegt.  Der Cursor
springt auf das Ende der vorhergehenden Linie, wenn auf der selben Zeile
kein weiteres Wort mehr zu finden ist.


Bewegen/nächste Zeile (<u>) und Bewegen/vorige Zeile (<o>)
----------------------------------------------------------

Diese beiden Funktionen bewegen den Cursor auf die vorhergehende (weiter
oben stehende) bzw.  auf die nachfolgende (weiter unten stehende) Zeile.
Die Spalte, in der sich der Cursor befindet, wird dabei nicht verändert.


Bewegen/Zeilenende (ESC <r>) und Bewegen/Zeilenanfang (ESC <l>)
---------------------------------------------------------------

Der Cursor wird entweder auf das erste oder das letzte Zeichen der
aktuellen Zeile gesetzt.


Bewegen/Tabulator (TAB)
-----------------------

Der Cursor wird normalerweise um 16 Zeichen nach rechts verschoben.
Wenn der Cursor über das Ende der Zeile hinauskommt, werden die
restlichen Zeichen mit Zwischenräumen aufgefüllt.  Die Tabulatortaste
findet beim Schreiben eines Redcode - Programmes verwendung, wenn ein
Befehlswort geschrieben werden soll.  Anstatt 16 Mal die Zwischenraum -
Taste zu drücken, kann einfach einmal der Tabulator batätigt werden.
Die Anzahl der Zeichen des Tabulatorsprunges können Sie mit der Funktion
"Spezial/Tabulator" in weiten Grenzen selbst bestimmen.


Bewegen/Cursor Home (ESC h) und Bewegen/Cursor uHome (ESC z)
------------------------------------------------------------

Setzt den Cursor in die linke obere bzw.  die linke untere Ecke des
Editorfensters.


Suchen/Vorw. suchen (ESC s)
---------------------------

In diesem Menustreifen finden sich verschiedene Funktionen zum
Durchsuchen von Text.  Sie können mit deren Hilfe bestimmte Wörter
finden und wahlweise durch andere Begriffe ersetzen.

"Vorw.  suchen" steht für "vorwärts suchen".  Nachdem Sie den Menupunkt
angewählt haben, können Sie einen Suchbegriff mit bis zu 77 Zeichen (die
Länge einer Zeile im Editor) eingeben.  Der Text wird dann beginnend bei
der aktuellen Cursorposition nach diesem Wort durchsucht.  Wenn eine
Stelle gefunden wird, die der Eingabe entspricht, wird der Cursor auf
das Ende des gefundenen Wortes gesetzt.  Wenn erfolglos gesucht wurde,
erscheint in der Statuszeile eine entsprechende Meldung und die Position
des Cursors bleibt unverändert.  In beiden Fällen befinden Sie sich
anschliessend wieder im normalen Eingabemodus des Editors.


Suchen/Rückw. suchen (ESC b)
----------------------------

Hier können Sie den Text in der umgekehrten Richtung nach einem Begriff
durchsuchen.  Die Eingabe erfolgt wie beim normalen Suchen, aber der
Cursor wird nach dem Auffinden eines Wortes an dessen Ende gesetzt.


Suchen/Suchen, Ersetzen (ESC p)
-------------------------------

Mit dieser Funktion können Sie den Text nach einem Wort durchsuchen und
alle so gefundenen Wörter automatisch durch einen zweiten Begriff
ersetzen lassen.  Der Ersatzbegriff darf wiederum bis zu 77 Zeichen lang
sein und wird gleich wie der Suchbegriff ein gegeben.  Wenn die Suche
abgeschlossen ist, erscheint eine Meldung in der Statuszeile und der
Cursor bleibt auf dem zuletzt ersetzten Wort positioniert.


Suchen/S. E. Fragen (ESC f)
---------------------------

Eigentlich ist dies dieselbe Funktion wie "Suchen, Ersetzen".  Der
einzige Unterschied ist, dass hier vor jedem Ersetzen eine Rückfrage in
der Statuszeile gestellt wird.  Wenn Sie das neu gefundene Wort wirklich
ersetzen wollen, drücken Sie die Taste "J" für Ja, ansonsten die Taste
"N" für Nein.  In beiden Fällen wird die Suche nach dem nächsten Wort
fortgesetzt, bis nichts mehr gefunden wird.


Suchen/gross/klein (ESC u)
--------------------------

Bei allen Suchfunktionen können Sie mit diesem Menupunkt wählen, ob
Gross- und Kleinbuchstaben unterschieden werden sollen oder nicht.  Wenn
der Haken vor dem Menupunkt gesetzt ist, werden Grossbuchstaben nicht
gleich bewertet wie Kleinbuchstaben.  Ein Beispiel: "Null" ist nicht
gleich "null", weil der erste Buchstabe einmal gross und einmal klein
vorkommt.  Wenn der Haken jedoch gelöscht wäre, würden die beiden Wörter
gleich behandelt werden.  Den Haken können Sie setzen bzw.  löschen,
indem Sie einfach den Menupunkt "gross/klein" einmal anwählen.


Spezial/Tabulator (AMIGA t)
---------------------------

Durch die Tabulatortaste kann um eine bestimmte Anzahl Zeichen im Text
vorwärts gesprungen werden.  Diese Weite des Tabulators nennen wir den
Tabulatorsprung, welcher im Redcode Editor frei wählbar ist.  Was
geschieht nun, wenn die Tabulatortaste gedrückt wird? Sollte sich der
Cursor mitten in einer schon geschriebenen Zeile befinden, verschiebt er
sich einfach um den Tabulatorsprung nach rechts.  Wenn sich die
Schreibposition aber schon am Ende einer Zeile befindet oder das
Zeilenende während des Sprunges erreicht, werden soviele Zwischenräume
angefügt, bis die Distanz des Sprunges erfüllt ist.  Der Cursor würde
sich in diesem Falle hinter dem letzten angehängten Leerzeichen
befinden.  Dieser Effekt ist beim Schreiben eines Redcode-Programmes
sehr nützlich, weil ja meistens nicht vor jeden Befehl eine Sprungmarke
zu stehen kommt.  Anstatt am Beginn jeder Zeile unzählige Male auf die
Leerschlagtaste zu hämmern, können Sie nun einfach den gewünschten
Tabulatorsprung einstellen (Standard ist 16 Zeichen) und fort an nur
noch die Tabulatortaste drücken.

"Spezial/Tabulator" erlaubt es Ihnen, die Grösse Ihres eigenen
Tabulatorsprunges frei auszuwählen.  In der Statuszeile erscheint eine
Aufforderung zur Eingabe einer Zahl.  Sie stellt die Anzahl der
Zwischenräume dar, die beim Betätigen der Tabulatortaste übersprungen
werden.  Die Zahl sollte grösser als Null und kleiner als 32 sein, damit
Sie den Tabulator noch vernünftig verwenden zu können.  Das Eintippen
erfolgt wie bei der Funktion "Bewegen/Zeile..." mit den normalen
Zifferntasten, das Korrigieren von Fehleingaben ist wiederum durch die
"Backspace-Taste" möglich.


Spezial/Makro eingeben (AMIGA u)
--------------------------------

Dies ist eine weitere leistungsfähige Einrichtung des Redcode Editors.
Die Funktionstasten F1 bis F10 und Shift-F1 bis Shift-F10 (zwanzig
Tasten) sind frei mit Zeichenketten Ihrer Wahl belegbar.  Diese
Zeichenketten werden Makros genannt, ein Wort, das aus der griechischen
Vorsilbe "makr" für "gross" oder "mächtig" gebildet wurde.  Eine
Anwendung von einem Makro wäre zum Beispiel die Belegung der
Funktionstaste Shift-F1 mit einem Label, das Sie oft benützen.  Ein
Makro darf bis zu 77 Stellen lang sein und beliebige Zeichen enthalten.

Wenn Sie die Funktion "Makro eingeben" starten, wird in der Statuszeile
eine Meldung ausgegeben, die das Betätigen einer der Funktionstasten
verlangt.  Dies ist die Taste, über die danach das Makro in den Text
eingefügt wird.  Danach kann genau wie bei der Wahl eines Dateinamens
beim Abspeichern die Zeichenkette des Makros eingetippt werden.  Beenden
Sie Ihre Eingabe schliesslich durch RETURN oder durch einen Klick in das
OK-Kästchen ab.

Positionieren Sie den Cursor irgendwo im Text und drücken Sie die mit
dem Makro belegte Funktionstaste.  Die vorhin eingegebene Zeichenkette
wird in den Text eingefügt und der Cursor erscheint wieder am Schluss
des neuen Textes.

Gewissermassen "von Haus aus" sind die Funktionstasten F1 bis F10 mit
den zehn Redcode-Befehlen belegt, aber Sie können natürlich auch diese
Makros wie oben beschrieben verändern.  Beachten Sie jedoch, dass dann
beim Anwählen einer der Befehlsfunktionen im "Redcode"-Menustreifen
nicht der aufgeführte Befehl, sondern Ihr nachträglich unter der
entsprechenden Funktionstaste abgelegtes Makro im Text eingefügt wird.


Spezial/Standard
----------------

Alle Einstellungen, die Sie verändert haben, werden durch die
Standardwerte ersetzt.  Eine Liste dieser Einstellungen finden Sie in
der Beschreibung zur Funktion "System/Einstellungen l." am Beginn dieses
Kapitels und im Anhang A.5.


Spezial/Glocke
--------------

Wenn Sie das Core Wars Programm frisch gestartet haben, ist die Glocke
eingeschaltet.  Sie merken dies, wenn Sie beim Schreiben einer Textzeile
mit dem Cursor über das 66.  Zeichen hinauskommen: Bei jedem Tastendruck
blitzt der Bildschirm einmal kurz auf.  Diese Einrichtung dient dazu,
Sie darauf aufmerksam zu machen, dass Sie fast das Ende einer Zeile
erreicht haben.  Diese optische Glocke ist eingeschaltet, wenn der Haken
neben dem Menupunkt "Glocke" gesetzt ist.  Natürlich können Sie den
Bildschirmblitz auch ausschalten, indem Sie einfach einmal "Glocke"
anwählen.  Der Haken wird dann gelöscht und der Bildschirm beruhigt sich
wieder.


Spezial/Status zeigen (ESC X)
-----------------------------

In der Statuszeile wird eine Meldung über den augenblicklichen Zustand
des Textes angezeigt: Die Zeile und die Spalte, in der sich der Cursor
befindet, Die Anzahl Bytes, die der Text umfasst (ein Byte ist ein
Zeichen), und die Anzahl Zeilen, über die sic h der Text erstreckt.
Diese Statusmeldung wird auch angezeigt, wenn Sie den Cursor mit der
Maus in das Editorfenster setzen.  Beachten Sie, dass die
Tastenkombination nicht das normale kleine, sondern das grosse X
verlangt.  Drücken Sie also nach der Esc-Ta ste gleichzeitig die Shift-
und die x-Taste, um diese Funktion aufzurufen.


Spezial/Zeit zeigen (ESC T)
---------------------------

Hier wird in der Statuszeile die aktuelle Zeit und das Datum angezeigt.
Auch diese Funktion verlangt wie "Status zeigen" beim Aufrufen über die
Tastatur das grosse T anstelle eines kleinen.




2.4 Assemblieren
________________


Um einen Kampf zwischen zwei Redcode Programmen ausführen zu können,
müssen Sie die Quelltexte der Programme zuerst in einen von MARS
verständlichen Code übersetzen.  Diese Umwandlung besorgt der Assembler.


2.4.1 Bedienung
---------------

Rufen Sie aus dem Menustreifen "Action" den "Assembler" auf.  Sie können
nun in einen Textrequester den Namen des zu übersetzenden Programmtextes
eingeben.  Nehmen wir an, Sie möchten das Programm "mice" assemblieren.
Es befindet sich im Verzeichnis "Beispiele" der Startdiskette.  Deshalb
lautet der Pfadname "Beispiele/Mice".  Drücken Sie die Return-Taste oder
klicken Sie mit der Maus in das OK-Gadget, um den Assembler laufen zu
lassen.

Auf dem Bildschirm erscheinen verschiedene Nachrichten, aus denen Sie
ersehen können, wann ein eventueller Fehler auftritt:

Kommentare löschen: Die Kommentare (wenn vorhanden) werden aus dem
Quelltext gelöscht.  Redcode-Befehle codieren: Alle verwendeten
Anweisungen werden gesucht und in Ihre entsprechenden Codes verwandelt.
Symboltabelle erstellen: Die Symbole werden erfasst und durch die Werte,
die sie darstellen, ersetzt.  Zwischenräume löschen: Alle überflüssigen
Leerschläge zwischen Befehlen und Argumenten werden gelöscht.  Argumente
auflösen und berechnen: Alle Argumente werden durch eine Zahl mit dem
vorangestellten Adressierungsmodus ersetzt.  Startzeile bestimmen: Wenn
das Symbol "start" verwendet wurde, beginnt die Ausführung bei dieser
Zeile, sonst bei der ersten gültigen Programmzeile.

Wenn die Assemblierung wegen einem Fehler im Quellcode abgebrochen
wurde, erscheint eine Fehlermeldung in einem Textkasten in der Mitte des
Bildschirmes.  Alle möglichen Meldungen sind im Abschnitt 2.9 dieses
Kapitels beschrieben.

Nach einer erfolgreichen Assemblierung muss das ausführbare
Redcode-Programm noch auf Diskette zurückgespeichert werden.  Zu diesem
Zweck erscheint ein neuer Textrequester, in dem der Programmname mit der
zusätzlichen Endung ".prg" angezeigt wird.  Wenn Sie mit diesem Namen
einverstanden Sind, können Sie wieder die Return-Taste drücken oder mit
der Maus in das OK-Gadget klicken.  Sie können den vorgeschlagenen Namen
natürlich noch ändern, denken Sie aber daran, dass Sie Ihren
ausführbaren Programmen eine besondere Endung verpassen sollten.  Das
Assemblieren kann hier übrigens zum letzten Mal noch abgebrochen werden,
wenn Sie das STOP-Gadget des Textrequesters anwählen.


2.4.2 Regeln zum Assembler
--------------------------

Hier folgt eine zusammenfassung aller Regeln zum Aufbau eines
Quelltextes, den der Assembler verstehen und übersetzen kann.


Symbole:

Ein Symbol ist ein Wort, das stellvertretend für einen Zahlenwert
verwendet wird.  Ein Symbol wird definiert, indem es an den Beginn einer
Befehlszeile des Quelltextes gesetzt wird.  Wenn Das Symbol in der
ersten Zeile definiert wird, besitzt es den Wert Null, in der zweiten
Zeile den Wert 1 und so weiter bis zum Ende des Programmes.  Jedes
Symbol muss genau einmal definiert werden.  Ein Symbol muss als erstes
Zeichen einen Buchstaben von a - z oder A - Z enthalten, danach dürfen
sowohl Zahlen als auch Buchstaben folgen.  Ein Symbol darf nicht länger
als 40 Zeichen sein und es dürfen nicht mehr als 30 Symbole in einem
Quelltext definiert werden.


Argumente:

Alle Argumente eines Befehls müssen angegeben werden.  Ein Argument darf
eine Zahl, ein Symbol, ein Ausdruck aus Symbolen oder das *-Zeichen
sein.  Jedes Argument kann mit einem der vier Zeichen #, $, @, <
adressiert werden (siehe auch Kapitel eins, Abschnitt 1.9).  Ein
Ausdruck darf aus Zahlen, Symbolen sowie den Operatoren + und - für eine
Addition bzw.  Subtraktion bestehen.  Alle anderen Zeichen (Klammern,
Multiplikation, Division) sind nicht erlaubt.  Zwischen Symbolen und
Zahlen müssen, zwischen Symbolen und Operatoren können Leerzeichen
enthalten sein.


Kommentare:

Um ein Redcode-Programm ausser dem Assembler auch einem Menschen
verständlich zu machen, können Kommentare verwendet werden.  Ein
Kommentar kann am Ende einer Befehlszeile stehen oder er kann eine ganze
Zeile des Quelltextes belegen.  Jeder Kommentar beginnt mit einem
;-Zeichen (Semikolon) und hört mit dem Zeilenende auf.  Falls schon das
erste Zeichen einer Redcode-Zeile ein Semikolon ist, wird die ganze
Zeile als Kommentar interpretiert.  Wenn dies nicht der Fall ist, nimmt
der Assembler an, dass eine normale Befehlszeile folgt.  Wenn eine Zeile
nur Leerzeichen oder gar keine Zeichen enthält, wird sie übersprungen.


Programmgrösse:

Der Assembler kann bis zu 400 Zeilen eines Quelltextes einlesen und
übersetzen.  Dies entspricht der Kapazität des Editors und sollte in den
meisten Fällen mehr als genug sein.




2.5 Der Kampf
_____________


Sie haben verschiedene Möglichkeiten, zwei Programme gegeineinander
kämpfen zu lassen.  Die Schlacht findet natürlich immer im MARS
Speicherfeld mit seinen 8000 Zellen statt, aber Sie können beliebige
Kombinationen von drei verschiedenen Anzeigemodi auswählen.  Diese drei
Modi dienen dazu, den Zustand des Speicherfeldes, die Anzahl Tasks der
Programme, die gerade bearbeiteten Anweisungen und vieles mehr
anzuzeigen.

Die Anzahl der Ausführungszyklen, bis ein Kampf für unentschieden
erklärt wird, kann ebenfalls geändert werden.  Laut "Core War Standards"
sind es 10000 Schritte für jedes Programm.  Weil sich dieser Wert
unserer Ansicht nach eher an der unteren Grenze befindet, kann er erhöht
oder vermindert werden und ist als Anfangswert bei Amiga - Core Wars auf
20000 Zyklen gesetzt.


2.5.1 Auswählen der Anzeigemodi
-------------------------------

Es gibt wie gesagt deren drei: Grafik, Status und Einzelschritt
(Zeitlupe).  Wenn Sie sich im Menustreifen "Optionen" umschauen, sehen
Sie die Punkte "Grafik", "Status" und "Trace".  "Trace" ist englisch und
steht für Zeitlupe: Eine Anzeige, mit deren Hilfe Sie die
Programmausführung verlangsamen und im Einzelschritt die beiden
Kampfprogramme verfolgen können.  Jede dieser Optionen können Sie durch
einfaches Anwählen durch die Maus ein- oder ausschalten.  Diese zwei
Zustände werden durch den jeweiligen Haken vor dem Menupunkt bestimmt:
Wenn der Haken erscheint, ist die Option eingeschaltet, wenn kein Haken
vorhanden ist, ist sie ausgeschaltet.


2.5.2 Zyklen
------------

Der vierte Punkt im Menustreifen "Optionen" ist "Zyklen".  Dadurch
können Sie bestimmen, wieviele Instruktionen jedes Programmes ausgeführt
werden sollen, bis ein Unentschieden eintritt.  Wenn Sie diesen
Menupunkt anwählen, fragt Core Wars nach der Anzahl Zyklen.  Der Wert,
der angezeigt wird, stellt die gerade wirksame Anzahl der Zyklen dar.
Diese beträgt nach jedem Neustart von Core Wars 10000.  Tippen Sie dann
eine beliebige Zahl zwischen eins und 99999 ein und klicken Sie nun mit
der Maus in das OK-Gadget.


2.5.3 Starten eines Kampfes
---------------------------

Das Starten eines Kampfes geht immer gleich vor sich: Sie rufen aus dem
Menustreifen "Action" den Punkt "Kampf" auf.  Anschliessend erscheint
ein grosser Textrequester, in den Sie die Namen von zwei Kampfprogrammen
eingeben sollen.  Klicken Sie dazu mit der Maus in einen der beiden
Balken und Tippen Sie den Pfadnamen eines assemblierten
Redcode-Programmes, z.  B.  "Beispiele/Mice.prg" (Endung .prg nicht
vergessen) ein.  Klicken Sie in den anderen Balken und wiederholen Sie
die Eingabe mit einem anderen Namen, z.B.  "Beispiele/Gnom.prg".  Nun
können Sie die Eingaben mit einem Klicken in das OK-Gadget bestätigen
oder durch das ABBRUCH-Gadget den Kampf abbrechen.

Wenn Sie "OK" gewählt haben, geht"s los.  Zuerst werden die beiden
Programme eingelesen, dann beginnt der Kampf.  Je nachdem, welche
Anzeigemodi Sie eingeschaltet haben, erscheinen mehr oder weniger
Fenster, die die gewünschten Informationen zum Kampfgeschehen enthalten:
Die Grafikanzeige, die Statusanzeige und der Einzelschrittmodus.

Sobald eines der Programme gewonnen hat oder ein Unentschieden
eingetreten ist (die eingestellte Anzahl der Zyklen wurde
überschritten, ohne dass eine Entscheidung stattfand), wird der Ausgang
des Kampfes angezeigt.  Sie können einen Kampf allerdings auch
vorzeitig abbrechen, indem Sie das Abbruch-Gadget mit der Maus
anklicken.  Dieses Gadget erscheint immer im oberen Teil des
Bildschirmes über allen anderen Anzeigen, sobald ein Kampf gestartet
wurde.

Der Ausgang des Kampfes wird ebenfalls mit einem Gadget angezeigt.  Sie
können irgendwo in diesen Textkasten hineinklicken, um schneller
zurück ins Hauptprogramm zu gelangen.  Anschliessend fragt Core Wars
nach, ob gleich ein weiterer Kampf gestartet werden soll.  Wenn Sie "ja"
anwählen, können Sie sofort die Namen von zwei neuen Kampfprogrammen
eingeben und weitermachen.  Mit "nein" kommen Sie entgültig ins
Hauptprogramm zurück.


2.6 Die Statusanzeige
---------------------

Sie dient dazu, einen Ueberblick über die Anzahl der abgearbeiteten
Zyklen (Programmschritte) und der Tasks der Programme zu erhalten.
Ferner ist die Statusanzeige auch nützlich, wenn Sie gleichzeitig den
Einzelschrittmodus eingeschaltet haben: Sie sehen dann die aktuelle
Adresse und den aktuellen Task jedes Programmes.  Abbildung 1 zeigt den
Status und den Einzelschrittmodus, wie sie auf dem Bildschirm
erscheinen.  Ganz oben sehen Sie die Namen der beiden Programme
eingeblendet, dazwischen ist das Abbruch-Gadget.  Im Fenster mit dem
Titel "Core Wars - Status" sind links und rechts zwei senkrechte Balken
gezeichnet, die grafisch wiedergeben, wieviele Tasks jedes Programmes zu
diesem Zeitpunkt laufen.  Die genaue Zahl steht jeweils rechts und links
daneben: für "mice.prg" sind es hier 27, für "gnom.prg" läuft nur ein
Task.  "Anzahl Zyklen" (oben Mitte) bedarf wohl keiner näheren Erklärung
mehr.  "aktuelle Adresse" und "aktueller Task" gibt jeweils die Nummer
der gerade ausgeführten Speicherzelle im MARS-Speicherfeld und die
Nummer des dazugehörigen Tasks an.  Wenn Sie die Programme nicht mit dem
Einzelschrittmodus angehalten haben, wechseln die einzelnen Zahlen im
Statusfenster sehr schnell.


2.7 Die Grafikanzeige
---------------------

Die grafische Darstellung des ganzen MARS-Speichers ist zweifellos
eines der interessantesten Features des Core Wars.  Sie können dadurch
hautnah mitverfolgen, welche Verwüstungen die Kampfprogramme im
Speicher anrichten, und welche der beiden Parteien die bessere Taktik
anwendet.  Es ist faszinierend, dabei zuzusehen, wie sich in einem Kampf
zwischen "mice" und "Mausefalle" die Mäusetasks hemmungslos vermehren,
um schliesslich doch nach und nach in die Fallen des Mäusefängers zu
tappen.

Die Grafikanzeige besteht am Anfang aus einem grossen schwarzen
Rechteck, das für das gesamte MARS-Speicherfeld steht.  Es setzt sich
aus 100 Zeilen zu 80 Punkten = 8000 Zellen zusammen, die mit der Zeit je
nach Verlauf eines Kampfes verschieden gefärbt werden.  Dabei stehen die
Farben für bestimmte Operationen, die mit der betroffenen
Speicherzelle angestellt wurden.

Jeder der beiden Konkurrenten in einem Kampf erhält eine der beiden
Farben Rot und Grün zugeordnet.  Diese Farben werden bei der Anzeige der
Programmnamen ganz oben im Bildschirm gezeigt.  Das linke (zuerst
eingegebene) Programm ist das Grüne, das rechte ist das Rote.  Ein
dunkelgrüner oder dunkelroter Farbpunkt im Grafikfenster steht für eine
Speicherzelle, die vom betreffenden Programm verändert wurde.  Ein
hellgrüner oder hellroter Farbpunkt steht dagegen für eine Zelle, die
schon von der jeweiligen Partei als Programmschritt ausgeführt wurde.
Man kann mit anderen Worten auch sagen, dass ein heller Farbton für eine
Zelle steht, die von einem Programmzeiger überstrichen wurde.



2.8 Die Zeitlupe (Trace)

Nur wenige Redcode-Programme laufen gleich auf Anhieb fehlerfrei.  Hier
hilft die Einzelschritt-Option "Trace" weiter: Sie können den Ablauf
eines Kampfprogrammes Schritt für Schritt, also gewissermassen in
Zeitlupe, verfolgen.  In der Abbildung 2 ist das Einzelschrittfenster
dargestellt.  Sie können dort zwei Gadgets namens "Schritt" und "Start"
erkennen.  Links und rechts daneben befinden sich zwei Kästen, in denen
ein Ausschnitt des jeweiligen Redcode-Programmes im Klartext aufgelistet
wird.  Wir nennen diese Kästen die Listfenster, den sich darin
befindenden Text das disassemblierte (zurückübersetzte)
Redcode-Programm.

Nach dem Beginn eines Kampfes mit eingeschaltetem Einzelschrittmodus
passiert erst mal gar nichts.  Vom linken (grünen) Kampfprogramm werden
sieben Zeilen entschlüsselt und im entsprechenden Fenster angezeigt.
Die mittlere, grün gedruckte Zeile ist die aktuelle Programmzeile, die
soeben ausgeführt wurde.  Alle Veränderungen, die diese Zeile im
MARS-Speicher hervorgerufen hat, werden im Listing schon berücksichtigt.

Wenn Sie jetzt mit der Maus das Schritt-Gadget anklicken, wird die
hervorgehobene Zeile ausgeführt und anschliessend füllt sich auch das
rechte Listfenster mit dem disassemblierten Programmtext des roten
Programmes.  Die rot angezeigte Zeile im Listing wurde soeben durch die
Betätigung des Schritt-Gadgets ausgeführt, und der ganze Vorgang beginnt
wieder von vorne.  Sie können sich auf diese Weise mit einzelnen
Schritten durch die beiden Programme durcharbeiten.  Wenn Sie mehrere
Schritte auf einmal zurücklegen wollen, können Sie das Start-Gadget
anwählen: Bis zur nächsten Betätigung von Start, Schritt (oder Abbruch)
wird der Kampf ohne Unterbrechung automatisch fortgeführt.  Dabei werden
die aktuellen Programmschritte natürlich nicht mehr im Klartext
angezeigt, weil dies den Kampf unnötig verzögern würde.

Mit den Listfenstern können auch beliebige Teile des MARS-Speichers
disassembliert werden.  Dazu dienen die vier Pfeile links und rechts
neben den Schritt/Start-Gadgets.  Durch Anklicken der Pfeile kann im
Speicherfeld nach oben oder unten gewandert werden: Mit dem linken
Pfeilpaar von der Position des grünen Programmzeigers aus, mit dem
rechtem Paar vom roten Zeiger aus.  Eine schnellere Möglichkeit, das
Listfenster zu positionieren, bietet sich durch die Grafikanzeige.  Wenn
Sie im Schritt-Modus den Mauszeiger in dieser Grafik an eine beliebige
Stelle setzen und einmal die linke Maustaste drücken, ist die Position
registriert.  Betätigen Sie nun einen der Pfeile, um den gewählten
Ausschnitt im Listfenster anzuzeigen.  Welches der beiden Fenster
verwendet wird, hängt von folgenden Punkten ab:

     o    Wenn der Mauszeiger auf eine grüne (hell oder dunkel)
          Speicherzelle gesetzt wurde, erscheint der disassemblierte
          Speicherbereich im linken Listfenster.
     o    Bei einer roten Zelle wird das rechte Listfenster verwendet.
     o    Bei einer schwarzen Zelle wird wieder im linken (grünen)
          Fenster angezeigt.
     o    Wenn zwei Punkte nacheinander angeklickt werden (rot, grün
          oder schwarz), werden beide Fenster verwendet.

Die Pfeile und die Positionierung per Maus ist unwirksam, sobald der
Kampf mit dem Start-Gadget fortgeführt wird.  Unabhängig vom
disassemblierten Speicherbereich befinden sich die beiden Programmzeiger
immer noch auf derselben Stelle, an der sie beim letzten Anhalten der
Ausführung waren.




2.9 Fehlermeldungen des Assemblers
__________________________________


Während des Assemblierens eines Redcode-Quelltextes können verschiedene
Assemblierfehler auftreten, die durch einen falsch aufgebauten Quelltext
hervorgerufen werden.  Sobald ein solcher Fehler gefunden wird, wird das
Assemblieren abgebrochen und in einem Textrequester eine Fehlernummer,
eine Beschreibung des Fehlers im Klartext und wenn immer möglich die
Programmzeile, in der der Fehler gefunden wurde, angezeigt.  Hier folgt
nun eine Liste aller Fehlernummern mit den entsprechenden Beschreibungen
und mit Hinweisen, wie die Fehler behoben werden können.  Das Zeichen
"#" ersetzt die Zeilennummer, die normalerweise angezeigt würde.


Fehler Nr. 0

Meldung:       Funktion konnte erfolgreich beendet werden.
Beschreibung:  Vorgesehen für den normalen Verlauf einer Assemblierung,
               wird jedoch nicht mehr verwendet.


Fehler Nr. 1

Meldung:       Es werden zuviele Symbole definiert. Letztes Symbol in
               Zeile #.
Beschreibung:  Der Assembler erlaubt höchstens 30 verschiedene Symbole
               in einem Redcode-Programm. Wenn die Anzahl überschritten
               wird, erscheint diese Fehlermeldung mit der Zeile, in der
               das 31. Symbol definiert wurde.
Abhilfe:       Beissen Sie in den sauren Apfel und ersetzen Sie die
               überzähligen Symbole durch die entsprechenden Zahlenwerte.


Fehler Nr. 2

Meldung:       In Zeile # wird ein Symbol benutzt, das nicht definiert
               wurde.
Beschreibung:  Der Wert eines Symbols wird in einer Anweisung benötigt,
               das Symbol wird jedoch im gesamten Programm nicht
               definiert (Es besitzt keinen Wert).
Abhilfe:       Meistens handelt es sich hier um einen simplen Tippfehler
               in einem Symbol. Wenn dies nicht der Fall ist, haben Sie
               es versäumt, das bewusste Symbol zu definieren. Beachten
               Sie, dass bei einer Definition das Symbol ganz am linken
               Rand einer Zeile beginnen muss.


Fehler Nr. 3

Meldung:       Ein Argument des Befehls in Zeile # ist zu lange.
Beschreibung:  Die Maximallänge eines Argumentes für einen Redcode-
               Befehl ist auf vierzig Zeichen begrenzt.    Diese Länge
               versteht sich auch auf einen ganzen Ausdruck, der
               mehrere Symbole enthalten kann.
Abhilfe:       Versuchen Sie, sich auf kürzere Symbole zu beschränken,
               vor allem dann, wenn komplizierte Ausdrücke als
               Befehlsargumente verwendet werden.


Fehler Nr. 5

Meldung:       In Zeile # wird ein nicht erlaubter Operator verwendet.
Beschreibung:  Als Operatoren sind nur die beiden Zeichen für Addition
               und Subtraktion, also "+" und "-", erlaubt.
Abhilfe:       Beachten Sie, dass der Redcode Assembler die Zeichen für
               Multiplikation und Division ("*" und "/") nicht kennt.
               Versuchen Sie, den fraglichen Ausdruck nur mit "+" und
               "-" zu formulieren.


Fehler Nr. 6

Meldung:       In Zeile # wird ein Operator falsch verwendet.
Beschreibung:  Fehler in der Schreibweise eines Ausdruckes.
Abhilfe:       Die Zeichen "+" und "-" dürfen nur in Form von Vorzeichen
               oder als Operator zwischen zwei Symbolen verwendet werden.


Fehler Nr. 7

Meldung:       Ein Allgemeiner Fehler der Befehlssyntax tritt in Zeile #
               auf.
Beschreibung:  Dieser Fehler kann in vielen Fällen auftreten und ist in
               einer allgemeinen Form nicht näher beschreibbar.
Abhilfe:       Fehlerhafte Zeile auf Tippfehler überprüfen.


Fehler Nr. 8 und Nr. 9

Meldung:       Der Befehl in Zeile Nr. # benötigt weniger Argumente als
               vorhanden sind.
oder:           Der Befehl in Zeile Nr. # benötigt mehr Argumente, als
               vorhanden sind.
Beschreibung:  Zu einem Befehl sind entweder zuviele oder zu wenige
               Argumente vorhanden.
Abhilfe:       Der Assembler erwartet als Trennzeichen zwischen zwei
               Argumenten ein Komma. Wenn Sie ein älteres Redcode-
               Programm abtippen, kann es sein, dass anstelle von Kommas
               nur Zwischenräume als Trennzeichen verwendet wurden.
               Weil unser Assembler Zwischenräume in den Argumenten
               selbst erlaubt (z. B. zwischen den Operatoren), mussten
               wir ein eindeutiges Trennzeichen wählen: das Komma.


Fehler Nr. 10

Meldung:       In Zeile # ist bei den Argumenten ein Kommafehler
               aufgetreten.
Beschreibung:  In dieser Zeile wurde ein Komma falsch angewendet.
Abhilfe:       Sie verwenden mehr als ein Komma als Trennzeichen,
               es handelt sich meist um einen normalen Tippfehler.


Fehler Nr. 11

Meldung:       Zeile # enthält keinen gültigen Redcode-Befehl.
Beschreibung:  Jede Zeile eines Quelltextes, die keine reine
               Kommentarzeile ist, muss eine gültige Redcodeanweisung
               enthalten.
Abhilfe:       Entweder wurde eine Kommentarzeile nicht durch ein
               führendes Semikolon (;) gekennzeichnet oder der Befehl
               in dieser Zeile wurde nicht grossgeschrieben.


Fehler Nr. 12

Meldung:       In Zeile # wird eine Sprungadresse unmittelbar
               angegeben.
Beschreibung:  Der Befehl JMP (springen) darf nicht unmittelbar
               adressiert werden.
Abhilfe:       Weil ein Redcode-Programm nicht herausfinden darf, an
               welche Stelle im Speicher es geladen wurde, ist es
               verboten, eine Zieladresse des JMP-Befehls unmittelbar
               anzugeben. Verwenden Sie eine der Adressierungen direkt,
               indirekt oder indirekt inkrement.


Fehler Nr. 13

Meldung:       In Zeile # wird die MOV-Zieladresse unmittelbar angegeben.
Beschreibung:  Das zweite Argument von MOV darf nicht unmittelbar
               adressiert werden.
Abhilfe:       Siehe Nr. 12.


Fehler Nr. 14

Meldung:       Zeile # enthält mehr als einen Redcode-Befehl.
Beschreibung:  Eine Zeile des Quelltextes darf nur eine Anweisung
               enthalten.
Abhilfe:       Teilen Sie die fehlerhafte Linie in zwei    Programmzeilen auf.


Fehler Nr. 15

Meldung:       In Zeile # wird die SPL-Zieladresse unmittelbar
               angegeben.
Beschreibung:  Die Zieladresse von SPL (split) darf nicht unmittelbar
               adressiert sein.
Abhilfe:       Siehe Nr. 12.


Fehler Nr. 16

Meldung:       In Zeile # wird ein Symbol zum zweiten Mal definiert.
Beschreibung:  Ein Symbol darf nur einmal ganz am Beginn einer
               Programmzeile stehen.
Abhilfe:       Wenn ein unbekanntes Wort am Beginn einer Programmzeile
               steht, nimmt der Assembler an, dass es als Sprungmarke
               eingesetzt werden soll und weist ihm den Wert dieser Zeile
               zu (das Symbol wird definiert). Ein Symbol kann jedoch nur
               einen Wert enthalten, deshalb erscheint diese Fehlermeldung
               bei einer weiteren definition einer Sprungmarke mit diesem
               Namen. Ersetzen Sie eine der beiden Definitionen mit einem
               anderen Namen.


Fehler Nr. 17

Meldung:       Ich kann keine Datei mit dem angegebenen Namen finden.
               Pfadname prüfen.
Beschreibung:  Der Quellcode ist nicht unter diesem Namen auf der
               Diskette vorhanden.
Abhilfe:       Sehen Sie sich die entsprechende Diskette mit der Workbench
               an, indem Sie jede Schublade (Directory, Verzeichnis) durch
               einen Doppelklick mit der Maus öffnen.  Für jeden Quellcode
               und für jedes schon übersetzte Programm erscheint ein Icon.
               Wenn Sie die bewusste Quelldatei gefunden haben, können Sie
               diese durch doppeltes Anklicken ansehen.


Fehler Nr. 18

Meldung:       Ein nicht näher beschreibbarer Diskettenfehler ist
               eingetreten.
Beschreibung:  Eine Datei (Programm, Text oder Einstellung) kann nicht
               ordnungsgemäss von Diskette eingelesen oder abgespeichert
               werden.
Abhilfe:       Der Grund kann (unter anderem) eine defekte Diskette sein.
               In diesem Falle sollten Sie den "DiskDoctor", ein
               Hilfsprogramm des CLI, benützen. Ebenfalls eine mögliche
               Ursache ist ein Bedienungsfehler, z. B. das Entfernen der
               Diskette während dem Schreiben oder Lesen von Daten.


Fehler Nr. 19

Meldung:       Die Diskette hat keinen freien Speicherplatz mehr.
Beschreibung:  Eine Datei (Programm, Text oder Einstellung) konnte nicht
               abgespeichert werden, weil die Diskette fast voll war.
Abhilfe:       Um Platz zu schaffen, können Sie alte Dateien, die Sie
               nicht mehr oft benützen, auf eine zweite Diskette
               umkopieren. Löschen Sie anschliessend die kopierten
               Dateien und wiederholen Sie den Versuch, die Daten
               abzuspeichern.


Fehler Nr. 20

Meldung:       Die Textzeile # im Quelltext ist zu lange.
Beschreibung:  Der Assembler kann Zeilen bis zu einer Länge von 77
               Zeichen bearbeiten. Wenn eine Zeile eines Redcode-
               Programmes länger ist, erscheint diese Fehlermeldung
               und der Assembliervorgang wird abgebrochen.
Abhilfe:       Dieser Fehler tritt nicht auf, wenn Sie zum Schreiben
               Ihrer Programme den Redcode-Editor verwenden. Wenn Sie
               einen anderen Editor (z.B. den CLI-Editor ED) verwenden,
               müssen Sie darauf achten, dass keine Programmzeile länger
               als 77 Zeichen wird. Diese Zahl ist nicht willkürlich
               gewählt, sondern sie ergibt sich aus der Anzahl Zeichen,
               die auf einem umrandeten Bildschirm dargestellt werden
               können. Wer seine Kampfprogramme mit einer
               Textverarbeitung schreibt, sollte den fertigen
               Programmtext im ASCII-Modus abspeichern (Die meisten
               Textverarbeitungen bieten diese Funktion).


Fehler Nr. 21

Meldung:       Der Quelltext besitzt mehr Zeilen, als ich bearbeiten kann.
Beschreibung:  Der Assembler kann nur Redcode-Programme mit einer Länge
               von bis zu 400 ausführbaren Zeilen übersetzen.
Abhilfe:       Die gibt es nicht. Ein Redcode-Programm darf nicht mehr
               als 400 Befehle enthalten. Unser Editor erlaubt
               Textlängen von bis zu 400 Zeilen, davon darf jede eine
               ausführbare Anweisung enthalten.


Fehler Nr. 22

Meldung:       Der Speicher des Amiga ist voll.
Beschreibung:  Der Assembler benötigt Speicherplatz, um ein Programm zu
               übersetzen - in diesem Fall sogar mehr, als das System
               zu bieten hat.
Abhilfe:       Wenn Sie zusätzlich zu Core Wars noch andere Programme
               laufen lassen, ist es möglich, dass der Speicher nicht
               ausreicht. Stoppen Sie dann das andere Programm, um mehr
               freie Bytes zu bekommen. Wenn nur Core Wars alleine läuft,
               sollten Sie diese Fehlermeldung eigentlich nicht zu sehen
               bekommen (Core Wars läuft auf allen Amigas mit mindestens
               512 KB RAM und einem Floppy).


Fehler Nr. 23

Meldung:       Die eingelesene Datei bietet keine verwertbaren
               Redcode-Befehle.
Beschreibung:  Ein Quelltext eines Redcode-Programmes muss mindestens
               einen Befehl enthalten.
Abhilfe:       Haben Sie die Befehle klein geschrieben? Der Assembler
               erkennt nur Befehle in Grossbuchstaben. Wenn ein Befehl
               jedoch ganz am Beginn einer Zeile steht hilft alles
               nichts: er wird dann als Symbol betrachtet. In solchen
               Fällen hilft die Funktion "Syntax Check" des Redcode-
               Editors.


Fehler Nr. 24

Meldung:       In Zeile # wird ein Symbol mit zuvielen Zeichen verwendet.
Beschreibung:  Der Assembler kann sich nur Symbole mit bis zu 40 Zeichen
               merken.
Abhilfe:       Hier bleibt nur der Weg, den zu langen Symbolnamen durch
               einen kürzeren zu ersetzen.


Fehler Nr. 25

Meldung:       In Zeile # ist ein Argument zu kurz oder unvollständig.
Beschreibung:  Der Ausdruck für ein Argument kann nicht ausgerechnet
               werden, weil ein Fehler im Aufbau des Ausdrucks vorliegt.
Abhilfe:       Meistens handelt es sich um Tippfehler. Die Operatoren
               verlangen (sofern es keine Vorzeichen sind) immer zwei
               Werte als Operanden, die links und rechts des Operator-
               zeichens stehen müssen.


Fehler Nr. 26

Meldung:       In Zeile # wird das Resultat des Ausdruckes unzulässig
               gross.
Beschreibung:  Vorgesehen für einen Ueberlauf (zu grosse Zahlen) während
               der Berechnung eines Ausdruckes. Der Fehler wird aber
               schon vom Assembler aufgefangen, indem er alle Zahlen,
               die grösser als 8000 werden, mit dieser Formel verkürzt:
               n = Rest von n / 8000. (in Basic etwa:
               n = n - int(n / 8000) * 8000).
               Lange Rede, kurzer Sinn: Sie werden Fehler. Nr. 26 nicht
               antreffen.


Fehler Nr. 27

Meldung:       Eine Adressierungsart in Zeile # passt nicht zum
               verwendeten Befehl.
Beschreibung:  Nicht für alle Redcode-Befehle sind alle Adressierungen
               erlaubt.
Abhilfe:       In der Befehlsbeschreibung in Kapitel eins, Abschnitt
               1.4, sind alle erlaubten Adressierungsarten erklärt.
               Eine Zusammenfassung dieser Seiten finden Sie in
               Kapitel 3, Abschnitt 3.3.4 in Form einer Befehlstabelle.


Fehler Nr. 28

Meldung:       Der Name der Programmdatei ist länger als 80 Zeichen.
Beschreibung:  Der Assembler (auch der Redcode-Editor) kann keine
               Dateinamen entgegennehmen, die länger als 80 Zeichen sind.
Abhilfe:       Hier können Sie nur eines machen: Verwenden Sie (auch im
               Sinne der Uebersichtlichkeit) kürzere Dateinamen.



2.10 Fehlermeldungen von MARS
-----------------------------

Auch während eines Kampfes zwischen zwei Redcode-Programmen können
verschiedene Fehler auftreten.  Diese sind jedoch in der Regel sehr
selten und meistens eine Folge von Veränderungen eines schon
assemblierten, ausführbaren Kampfprogrammes durch einen Diskettenmonitor
oder ähnliches.  Eine MARS-Fehlermeldung deutet deshalb oft auf eine
nach der Assemblierung veränderte Programmdatei hin, sei es nun
mutwillig oder durch eine fehlerhafte Diskette.  Eine Ausnahme ist der
Fehler "Keine Objektdatei".  Er kann auch dann auftreten, wenn anstelle
eines Kampfprogrammes ein noch nicht übersetzter Quelltext ausgeführt
werden soll, z.  B.  wenn Sie die Endung ".prg" beim Wählen eines
Kampfprogrammes nicht eingegeben haben.  Hier folgt eine Liste aller
Fehlermeldungen, die bei einem Kampf auftreten können.  Zu der
jeweiligen Fehlernummer ist die Meldung im Klartext und eine Erklärung
des Fehlers aufgeführt.


Fehler Nr. 1

Meldung:       Illegaler Opcode im Programm
Beschreibung:  Ein bereits übersetztes Programm enthält eine Anweisung,
               die der MARS-Simulation nicht bekannt ist.
Abhilfe:       Hier muss ein Diskettenfehler vorliegen. Der Assembler
               kann nur Opcodes erzeugen, die MARS versteht. Assemblieren
               Sie den Programmtext neu und versuchen Sie einen neuen
               Kampf.


Fehler Nr. 2

Meldung:       Illegaler Adressierungsmodus
Beschreibung:  In einem bereits übersetzten Programm wird eine nicht
               erlaubte Adressierungsart verwendet.
Abhilfe:       Der Assembler kann wie bei Fehler Nr. 1 nur erlaubte
               Adressierungsarten erzeugen. Massnahme siehe Fehler Nr. 1.


Fehler Nr. 3

Meldung:       Ueberlauf in einer MARS-Zelle
Beschreibung:  Ein ausführbares Programm enthält Argumente, die grösser
               sind, als das MARS-Speicherfeld Zellen enthält: 8000.
Abhilfe:       Der Redcode-Assembler kann nur Argumente erzeugen, die
               kleiner oder gleich der grössten Adresse im MARS-Speicher
               sind. Massnahme siehe Fehler Nr. 1.


Fehler Nr. 4

Meldung:       Objektfile zu lang zum Einlesen
Beschreibung:  Das Kampfprogramm kann wegen Ueberlänge nicht eingelesen
               werden.
Abhilfe:       Der Quelltext muss gekürzt und neu assembliert werden.
               Versuchen Sie jedoch zuerst, den Quelltext unverändert neu
               zu assemblieren.


Fehler Nr. 5

Meldung:       Objektfile nicht gefunden
Beschreibung:  Eines der beiden Kampfprogramme konnte unter dem
               angegebenen Namen nicht gefunden werden.
Abhilfe:       Ueberprüfen Sie den Pfadnamen und die Endung, die
               normalerweise ".prg" sein sollte.


Fehler Nr. 6

Meldung:       Kein richtiges Objektfile
Beschreibung:  Bei der als Kampfprogramm angegebenen Datei handelt es
               sich nicht um ein zuvor assembliertes Programm.
Abhilfe:       Der MARS-Simulator hat zwar die Datei gefunden, die Sie
               gewählt haben, diese ist jedoch nicht ausführbar. Haben
               Sie an die Endung ".prg" gedacht?


Fehler Nr. 7

Meldung:       Kampf durch Operator abgebrochen
Beschreibung:  Ein Kampf wurde durch Anklicken des Abbruchgadgets
               vorzeitig beendet.
Abhilfe:       Keine eigentliche Fehlermeldung.


Fehler Nr. 8

Meldung:       Kein Speicher verfügbar
Beschreibung:  MARS bekommt vom Betriebssystem für das 8000 Zellen
               umfassende Speicherfeld nicht genügend freien RAM-Speicher.
Abhilfe:       Wenn zusätzlich zu Core Wars noch andere Programme auf
               Ihrem Amiga laufen, kann es zu Speichermangel kommen.
               Wenn dies eintritt, sollten Sie alle anderen,
               gleichzeitig laufenden Programme beenden. Wenn Core Wars
               aber alleine einen 512 KByte-Amiga zur Verfügung hat,
               sollte dieser Fehler nicht auftreten. Amiga-Intern benötigt
               eine MARS-Zelle 7 Bytes, das ganze Speicherfelde deshalb
               56000 Bytes. Im Titelbalken der Workbench wird der freie
               Speicher dauernd angezeigt, Sie können so ungefähr
               abschätzen, wieviel Speicher noch fehlt.



2.10.1 Fehlender Speicherplatz
------------------------------

Es kann auf 512-KByte Amigas vorkommen, dass zuwenig Speicher zur
Verfügung steht, wenn ein neues Fenster (z.B. der Editor) geöffnet
werden soll. Core Wars versucht dann automatisch, die Workbench zu
schliessen, so dass nur noch der Core Wars Bildschirm vorhanden ist.
Wenn im Workbench-Bildschirm noch Fenster geöffnet sind, sollten diese
unbedingt mit der Maus geschlossen werden. Auch gleichzeitig laufende
Programme müssen gestoppt und verlassen werden, um mehr Speicher zu
erhalten.